home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / program / pxbud.zip / PDXFLD.CPP < prev    next >
C/C++ Source or Header  |  1991-05-17  |  15KB  |  506 lines
  1. /*┌───────────────────────────────────────────────────────────────────────┐
  2.   │                                                                       │
  3.   │   Module:  PDXFLD.CPP                                                 │
  4.   │   Author:  Rick Kligman                                               │
  5.   │   Purpose: Source code for Field class                                │
  6.   │                                                                       │
  7.   │   Last Modified: 05-17-91 00:34am                                     │
  8.   │                                                                       │
  9.   │   Copyright 1991 Rick Kligman                                         │
  10.   │   This code may be freely used and distributed in commercial apps     │
  11.   │   provided some mention of PXBuddy++ is made in the documentation.    │
  12.   │                                                                       │
  13.   │   Version 1.00                                                        │
  14.   └───────────────────────────────────────────────────────────────────────┘ */
  15.  
  16. #include "pdxfld.h"
  17.  
  18. #ifndef   __STDIO_H
  19.   #include <stdio.h>
  20. #endif
  21.  
  22. #include "pdxtbl.h"
  23.  
  24. //    ╓───────────────────────────────────────────────────────────────╖
  25. //    ║                 Constructor for absfld class                  ║
  26. //    ╚═══════════════════════════════════════════════════════════════╝
  27.  
  28. absfld::absfld()
  29. {
  30. }
  31.  
  32. //    ╓───────────────────────────────────────────────────────────────╖
  33. //    ║                 Destructor  for absfld class                  ║
  34. //    ╚═══════════════════════════════════════════════════════════════╝
  35.  
  36. absfld::~absfld()
  37. {
  38. }
  39.  
  40. //    ╓───────────────────────────────────────────────────────────────╖
  41. //    ║                 Constructor for CharFld class                 ║
  42. //    ╚═══════════════════════════════════════════════════════════════╝
  43.  
  44. CharFld::CharFld()
  45. {
  46.   size = 0;
  47. }
  48.  
  49. //    ╓───────────────────────────────────────────────────────────────╖
  50. //    ║                 Destructor  for CharFld class                 ║
  51. //    ╚═══════════════════════════════════════════════════════════════╝
  52.  
  53. CharFld::~CharFld()
  54. {
  55.   if (size)
  56.       delete data;
  57. }
  58.  
  59. //    ╓─────────────────────────────────────────────────────────────╖
  60. //    ║                 Initialize CHAR Field                       ║
  61. //    ╚═════════════════════════════════════════════════════════════╝
  62.  
  63. int CharFld::setinfo(pxtable& tblptr, char *fldname)
  64. {
  65.   int     err;
  66.   char    fldtype [6];    // will hold len of field...A5, A23, A176 etc..
  67.  
  68.   tblp = &tblptr;
  69.  
  70.   err = PXFldHandle(tblp->th, fldname, &fh);
  71.   CKERR;
  72.  
  73.   err = PXFldType(tblp->th, fh, 6, fldtype);
  74.   CKERR;
  75.  
  76.   size = atoi(fldtype + 1) + 1;       // get len of field plus NULL char
  77.  
  78.   data = new char [size];             // allocate memory for var storage
  79.   if ( ! data )
  80.       return (PXERR_OUTOFMEM);
  81.  
  82.   return PXSUCCESS;
  83. }
  84.  
  85. //    ╓─────────────────────────────────────────────────────────────╖
  86. //    ║             Read CHAR Field from record buffer              ║
  87. //    ╚═════════════════════════════════════════════════════════════╝
  88.  
  89. int CharFld::get()
  90. {
  91.   int   blank;
  92.   int   err;
  93.  
  94.   err = PXFldBlank(tblp->rh, fh, &blank);
  95.   CKERR;
  96.  
  97.   if (blank)                                // char field was blank
  98.       data [0] = NULL;
  99.   else
  100.       err = PXGetAlpha(tblp->rh, fh, size, data);
  101.  
  102.   return (err);       // if no error then PXSUCCESS will be returned
  103. }
  104.  
  105.  
  106. // ╓─────────────────────────────────────────────────────────────────────────╖
  107. // ║                 Overload = to put contents into class                   ║
  108. // ╚═════════════════════════════════════════════════════════════════════════╝
  109.  
  110. void  CharFld::operator = (char *newval)
  111. {
  112.   strncpy(data, newval, size);
  113.   data [size - 1] = NULL;         // terminate the string
  114. }
  115.  
  116. //    ╓─────────────────────────────────────────────────────────────╖
  117. //    ║              Write CHAR Field to record buffer              ║
  118. //    ╚═════════════════════════════════════════════════════════════╝
  119.  
  120. int CharFld::put(int)
  121. {
  122.   int   err;
  123.  
  124.   err = PXPutAlpha(tblp->rh, fh, data);
  125.  
  126.   return (err);       // if no error then PXSUCCESS will be returned
  127. }
  128.  
  129. //    ╓─────────────────────────────────────────────────────────────╖
  130. //    ║                    Search a CHAR Field                      ║
  131. //    ╚═════════════════════════════════════════════════════════════╝
  132.  
  133. int CharFld::search(char *srchvar, int mode)
  134. {
  135.   int   err;
  136.   RECORDHANDLE  newrh;
  137.  
  138.   err = PXRecBufOpen(tblp->th, &newrh);
  139.   CKERR;
  140.  
  141.   err = PXRecBufEmpty(newrh);
  142.   CKERR;
  143.  
  144.   err = PXPutAlpha(newrh, fh, srchvar);
  145.   if ( err ) {
  146.       PXRecBufClose(newrh);
  147.       return err;
  148.   }
  149.  
  150.   err = search_fld(tblp->th, newrh, tblp->keyed, mode);
  151.  
  152.   PXRecBufClose(newrh);
  153.  
  154.   return (err);       // if no error then PXSUCCESS will be returned
  155. }
  156.  
  157. //    ╓───────────────────────────────────────────────────────────────╖
  158. //    ║                 Constructor for ShortFld class                ║
  159. //    ╚═══════════════════════════════════════════════════════════════╝
  160.  
  161. ShortFld::ShortFld()
  162. {
  163. }
  164.  
  165. //    ╓───────────────────────────────────────────────────────────────╖
  166. //    ║                 Destructor for ShortFld class                 ║
  167. //    ╚═══════════════════════════════════════════════════════════════╝
  168.  
  169. ShortFld::~ShortFld()
  170. {
  171. }
  172.  
  173.  
  174. //    ╓─────────────────────────────────────────────────────────────╖
  175. //    ║                 Initialize SHORT Field                      ║
  176. //    ╚═════════════════════════════════════════════════════════════╝
  177.  
  178. int ShortFld::setinfo(pxtable &tblptr, char *fldname)
  179. {
  180.   int     err;
  181.  
  182.   tblp = &tblptr;
  183.  
  184.   err = PXFldHandle(tblp->th, fldname, &fh);
  185.  
  186.   return (err);       // if no error then PXSUCCESS will be returned
  187. }
  188.  
  189. //    ╓─────────────────────────────────────────────────────────────╖
  190. //    ║             Read SHORT Field from record buffer             ║
  191. //    ╚═════════════════════════════════════════════════════════════╝
  192.  
  193. int ShortFld::get()
  194. {
  195.   int   blank;
  196.   int   err;
  197.  
  198.   err = PXFldBlank(tblp->rh, fh, &blank);
  199.   CKERR;
  200.  
  201.   if (blank)                          // short field was blank
  202.       data = 0;
  203.   else
  204.       err = PXGetShort(tblp->rh, fh, &data);
  205.  
  206.   return (err);       // if no error then PXSUCCESS will be returned
  207. }
  208.  
  209. //    ╓─────────────────────────────────────────────────────────────╖
  210. //    ║             Write SHORT Field to record buffer              ║
  211. //    ╚═════════════════════════════════════════════════════════════╝
  212.  
  213. int ShortFld::put(int blank)
  214. {
  215.   int   err;
  216.  
  217.   if ( data == 0 && blank )
  218.       err = PXPutBlank(tblp->rh, fh);
  219.   else
  220.       err = PXPutShort(tblp->rh, fh, data);
  221.  
  222.   return (err);       // if no error then PXSUCCESS will be returned
  223. }
  224.  
  225. //    ╓─────────────────────────────────────────────────────────────╖
  226. //    ║                   Search a SHORT Field                      ║
  227. //    ╚═════════════════════════════════════════════════════════════╝
  228.  
  229. int ShortFld::search(short srchvar, int mode)
  230. {
  231.   int   err;
  232.   RECORDHANDLE  newrh;
  233.  
  234.   err = PXRecBufOpen(tblp->th, &newrh);
  235.   CKERR;
  236.  
  237.   err = PXPutShort(newrh, fh, srchvar);
  238.   if ( err ) {
  239.       PXRecBufClose(newrh);
  240.       return err;
  241.   }
  242.  
  243.   err = search_fld(tblp->th, newrh, tblp->keyed, mode);
  244.  
  245.   PXRecBufClose(newrh);
  246.  
  247.   return (err);       // if no error then PXSUCCESS will be returned
  248. }
  249.  
  250. //    ╓───────────────────────────────────────────────────────────────╖
  251. //    ║                 Constructor for DblFld class                  ║
  252. //    ╚═══════════════════════════════════════════════════════════════╝
  253.  
  254. DblFld::DblFld()
  255. {
  256. }
  257.  
  258. //    ╓───────────────────────────────────────────────────────────────╖
  259. //    ║                 Destructor for DblFld class                   ║
  260. //    ╚═══════════════════════════════════════════════════════════════╝
  261.  
  262. DblFld::~DblFld()
  263. {
  264. }
  265.  
  266. //    ╓─────────────────────────────────────────────────────────────╖
  267. //    ║                 Initialize DOUBLE Field                     ║
  268. //    ╚═════════════════════════════════════════════════════════════╝
  269.  
  270. int DblFld::setinfo(pxtable &tblptr, char *fldname)
  271. {
  272.   int     err;
  273.  
  274.   tblp = &tblptr;
  275.  
  276.   err = PXFldHandle(tblp->th, fldname, &fh);
  277.  
  278.   return (err);       // if no error then PXSUCCESS will be returned
  279. }
  280.  
  281. //    ╓─────────────────────────────────────────────────────────────╖
  282. //    ║             Read DOUBLE Field from record buffer            ║
  283. //    ╚═════════════════════════════════════════════════════════════╝
  284.  
  285. int DblFld::get()
  286. {
  287.   int   blank;
  288.   int   err;
  289.  
  290.   err = PXFldBlank(tblp->rh, fh, &blank);
  291.   CKERR;
  292.  
  293.   if (blank)                          // double field was blank
  294.       data = 0;
  295.   else
  296.       err = PXGetDoub(tblp->rh, fh, &data);
  297.  
  298.   return (err);       // if no error then PXSUCCESS will be returned
  299. }
  300.  
  301. //    ╓─────────────────────────────────────────────────────────────╖
  302. //    ║             Write DOUBLE Field to record buffer             ║
  303. //    ╚═════════════════════════════════════════════════════════════╝
  304.  
  305. int DblFld::put(int blank)
  306. {
  307.   int   err;
  308.  
  309.   if ( data == 0 && blank )
  310.       err = PXPutBlank(tblp->rh, fh);
  311.   else
  312.       err = PXPutDoub(tblp->rh, fh, data);
  313.  
  314.   return (err);       // if no error then PXSUCCESS will be returned
  315. }
  316.  
  317. //    ╓─────────────────────────────────────────────────────────────╖
  318. //    ║                   Search a DOUBLE Field                     ║
  319. //    ╚═════════════════════════════════════════════════════════════╝
  320.  
  321. int DblFld::search(double srchvar, int mode)
  322. {
  323.   int   err;
  324.   RECORDHANDLE  newrh;
  325.  
  326.   err = PXRecBufOpen(tblp->th, &newrh);
  327.   CKERR;
  328.  
  329.   err = PXPutDoub(newrh, fh, srchvar);
  330.   if ( err ) {
  331.       PXRecBufClose(newrh);
  332.       return err;
  333.   }
  334.  
  335.   err = search_fld(tblp->th, newrh, tblp->keyed, mode);
  336.  
  337.   PXRecBufClose(newrh);
  338.  
  339.   return (err);       // if no error then PXSUCCESS will be returned
  340. }
  341.  
  342. //    ╓───────────────────────────────────────────────────────────────╖
  343. //    ║                 Constructor for DateFld class                 ║
  344. //    ╚═══════════════════════════════════════════════════════════════╝
  345.  
  346. DateFld::DateFld()
  347. {
  348. }
  349.  
  350. //    ╓───────────────────────────────────────────────────────────────╖
  351. //    ║                 Destructor for DateFld class                  ║
  352. //    ╚═══════════════════════════════════════════════════════════════╝
  353.  
  354. DateFld::~DateFld()
  355. {
  356. }
  357.  
  358. //    ╓─────────────────────────────────────────────────────────────╖
  359. //    ║                 Initialize DATE Field                       ║
  360. //    ╚═════════════════════════════════════════════════════════════╝
  361.  
  362. int DateFld::setinfo(pxtable &tblptr, char *fldname)
  363. {
  364.   int     err;
  365.  
  366.   tblp = &tblptr;
  367.  
  368.   err = PXFldHandle(tblp->th, fldname, &fh);
  369.  
  370.   return (err);       // if no error then PXSUCCESS will be returned
  371. }
  372.  
  373. //    ╓─────────────────────────────────────────────────────────────╖
  374. //    ║             Read DATE Field from record buffer              ║
  375. //    ╚═════════════════════════════════════════════════════════════╝
  376.  
  377. int DateFld::get()
  378. {
  379.   int   blank;
  380.   int   err;
  381.   int   mo, da, yr;
  382.  
  383.   err = PXFldBlank(tblp->rh, fh, &blank);
  384.   CKERR;
  385.  
  386.   if (blank) {                        // date field was blank
  387.       strcpy(datastr, "");
  388.   }
  389.   else {
  390.       err = PXGetDate(tblp->rh, fh, &data);
  391.       CKERR;
  392.       PXDateDecode(data, &mo, &da, &yr);
  393.       yr -= 1900;
  394.       if ( yr < 0 )     // in case we get something we didn't expect!
  395.           yr = 0;
  396.       sprintf(datastr, "%.2i/%.2i/%.2i", mo, da, yr);
  397.   }
  398.  
  399.   return (err);       // if no error then PXSUCCESS will be returned
  400. }
  401.  
  402. //    ╓─────────────────────────────────────────────────────────────╖
  403. //    ║              Write DATE Field to record buffer              ║
  404. //    ╚═════════════════════════════════════════════════════════════╝
  405.  
  406. int DateFld::put(int)
  407. {
  408.   int   err;
  409.  
  410.   //  if the date is blank it can be one of two things. If the user never
  411.   //  enters the field then it will be NULL. If the user does go through
  412.   //  the field and leaves it blank, Vermont converts the date to 00/00/00
  413.  
  414.   if ( *datastr == NULL )
  415.       err = PXPutBlank(tblp->rh, fh);
  416.   else
  417.       err = PXPutDate(tblp->rh, fh, data);
  418.  
  419.   return (err);       // if no error then PXSUCCESS will be returned
  420. }
  421.  
  422. //    ╓─────────────────────────────────────────────────────────────╖
  423. //    ║          Search a DATE Field with CHAR String               ║
  424. //    ╚═════════════════════════════════════════════════════════════╝
  425. #if 0
  426. int DateFld::search(char *srchvar, int mode)
  427. {
  428.   int   err = -1;
  429.   RECORDHANDLE  newrh;
  430.  
  431.   err = PXRecBufOpen(tblp->th, &newrh);
  432.   CKERR;
  433.  
  434.   err = PXPutDate(newrh, fh, srchvar);
  435.   if ( err ) {
  436.       PXRecBufClose(newrh);
  437.       return err;
  438.   }
  439.  
  440.   err = search_fld(tblp->th, newrh, tblp->keyed, mode);
  441.  
  442.   PXRecBufClose(newrh);
  443.  
  444.   return (err);       // if no error then PXSUCCESS will be returned
  445. }
  446. #endif
  447.  
  448. //    ╓───────────────────────────────────────────────────────────╖
  449. //    ║                   Convert String to DATE                  ║
  450. //    ╚═══════════════════════════════════════════════════════════╝
  451.  
  452. int DateFld::operator = (char *newval)
  453. {
  454.   int   mo, da, yr, err;
  455.   char  temp [3];
  456.  
  457.   strncpy(datastr, newval, 11);
  458.   datastr [10] = NULL;
  459.  
  460.   temp [0] = *newval;
  461.   temp [1] = *(newval + 1);
  462.   temp [2] = NULL;
  463.  
  464.   mo = atoi(temp);
  465.  
  466.   temp [0] = *(newval + 3);
  467.   temp [1] = *(newval + 4);
  468.  
  469.   da = atoi(temp);
  470.  
  471.   temp [0] = *(newval + 6);
  472.   temp [1] = *(newval + 7);
  473.  
  474.   yr = atoi(temp);
  475.  
  476.   err = PXDateEncode(mo, da, yr, &data);
  477.  
  478.   return ( err );
  479. }
  480.  
  481. //    ╓───────────────────────────────────────────────────────────╖
  482. //    ║                       Search a Field                      ║
  483. //    ╚═══════════════════════════════════════════════════════════╝
  484.  
  485. int absfld::search_fld(TABLEHANDLE th, RECORDHANDLE rh, int keyed, int mode)
  486. {
  487.   int   err;
  488.  
  489.   if ( ! keyed )          // non keyed searches need to go to top of table
  490.       PXRecGoto(th, 1);
  491.  
  492.   //  extra if on CLOSESTRECORD is done because even if it finds something
  493.   //  it will return RECNOTFOUND since it is an inexact match
  494.  
  495.   if ( fh == 1 && keyed )
  496.       err = PXSrchKey(th, rh, fh, mode);
  497.   else
  498.       err = PXSrchFld(th, rh, fh, mode);
  499.  
  500.   if (mode == CLOSESTRECORD && err == PXERR_RECNOTFOUND)
  501.       err = PXSUCCESS;
  502.  
  503.   return (err);       // if no error then PXSUCCESS will be returned
  504. }
  505.  
  506.